package com.lock.type;

import java.util.concurrent.locks.Lock;

/**
 * 1.可重入锁
 *      juc 包中的  ReentrantLock 与 synchronized 都是可以重入锁
 * 2. 原理
 *  下面是 JUC 包中 ReentrantLock 可重入锁的实现
 *
 *    if (current == getExclusiveOwnerThread()) {
 *
 *         int nextc = c + acquires;
 *         if (nextc < 0) // overflow
 *             throw new Error("Maximum lock count exceeded");
 *         setState(nextc);
 *         return true;
 *     }
 *    使用一个state表示线程状态，到state = 0 时，则表示没有线程加锁，如果 state 为 1，则有线程加锁，
 *    这时候再执行加锁操作，则直接把state状态值加1，解锁则是每次unlock的时候state -1 ,直到state变成0，才真正解锁。
 */
public class ReentrantLock {

    private Lock lock = new java.util.concurrent.locks.ReentrantLock();

    private volatile int a = 0;

//    public void run(){
//
//
//        lock.lock();
//
//        try {
//
//            run1();
//            a++;
//
//        }finally {
//
//            lock.unlock();
//        }
//
//    }
//
//    public void run1(){
//
//
//        lock.lock();
//
//        try {
//
//            a++;
//
//        }finally {
//
//            lock.unlock();
//        }
//
//    }

    public synchronized void run(){


            run1();
            a++;

    }

    public synchronized void run1(){

            a++;
    }

    public static void main(String[] args) {


        ReentrantLock reentrantLock = new ReentrantLock();


        for (int i = 0; i < 10; i++) {

            new Thread(()->{

                reentrantLock.run();
            }).start();
        }

        while (Thread.activeCount() > 2){

            Thread.yield();
        }

        System.out.println(reentrantLock.a);
    }
}
